Verify each finding against the current code and only fix it if needed.

Inline comments:
In `@docs/designs/component-library.md`:
- Line 77: Add language identifiers to all fenced code blocks in the component
library doc (the directory structure and visual example blocks) so linting
recognizes them; specifically update each triple-backtick block (the directory
structure example and other plaintext examples around the visual examples) to
start with ```text instead of ```; ensure every fenced block between the noted
examples includes the `text` language tag.

In `@packages/core/src/ui/display/alert.tsx`:
- Line 79: The component coerces ReactNode to a string via String(children)
which yields "[object Object]" for JSX; change the prop type so
AlertProps.children is string (not ReactNode), update any usages/prop types that
reference AlertProps and the component signature, and then use children directly
when building contentStr (referencing contentStr and the component that reads
AlertProps.children) to ensure only text is accepted and rendered correctly.

In `@packages/core/src/ui/display/progress-bar.tsx`:
- Line 67: The calculation of ratio in the ProgressBar component can divide by
zero; update the ratio computation (the const ratio in progress-bar.tsx /
ProgressBar) to guard against max === 0 (or non-positive max) before
dividing—e.g., if max is zero or <= 0 treat ratio as 0 (or clamp appropriately),
otherwise compute Math.min(1, Math.max(0, value / max)); apply the same guard
anywhere else that uses value/max.

In `@packages/core/src/ui/display/status-message.tsx`:
- Line 59: The Text element in StatusMessage is coercing children with
String(children) which breaks ReactNode rendering; update the Text rendering in
the StatusMessage component to output children as a ReactNode instead of
string-coercing it (preserve the intended leading space by rendering an explicit
space node or spacing prop and then render children directly). Locate the Text
line that currently reads <Text>{` ${String(children)}`}</Text> and replace it
so it renders a literal space (if needed) and the children ReactNode without
calling String(), ensuring complex children (JSX, elements) render correctly.

In `@packages/core/src/ui/prompts/autocomplete.tsx`:
- Around line 131-139: The Delete key is currently treated the same as
Backspace; update the key handling so key.backspace removes the character before
the cursor (keep using removeCharAt(search, cursorOffset - 1), decrement
cursorOffset and setFocusIndex(0)), while key.delete removes the character at
the cursor (call removeCharAt(search, cursorOffset) only when cursorOffset <
search.length, do not decrement cursorOffset, and still call setSearch and
setFocusIndex(0)); ensure both branches return after handling. Reference the
current handlers around key.backspace / key.delete, removeCharAt, setSearch,
setCursorOffset, and setFocusIndex.

In `@packages/core/src/ui/prompts/group-multi-select.tsx`:
- Around line 245-255: The moveFocus function can land on a disabled option at
the list boundary; update moveFocus(current: number, direction: number, items:
readonly FlatItem[]) to scan in the given direction until it finds an enabled
option and return that index, but if the scan reaches out-of-bounds without
finding any enabled option, return the original current index instead of the
last in-bounds index. Use the existing symbols (current, direction, items,
FlatItem, item.kind === 'option' and item.option.disabled) to implement a loop
that advances next while skipping disabled options and stops with current if no
enabled candidate is found.

In `@packages/core/src/ui/prompts/multi-select.tsx`:
- Around line 141-151: The OptionRow elements use option.label as the React key
which can collide; update the key in the map that renders OptionRow (the block
passing option, indicator, isFocused, isSelected, isDisabled) to use a stable
unique identifier such as option.value (or if value may not be unique, a
combined key like `${option.value}-${index}` or an explicit id field) instead of
option.label so React reconciliation is deterministic; locate the map that
renders OptionRow (references: OptionRow, option.label, focusedIndex) and
replace the key accordingly.

In `@packages/core/src/ui/prompts/navigation.ts`:
- Around line 98-110: The exported function resolveInitialIndex currently
accepts two positional parameters; change its signature to use a single object
parameter with destructured properties (e.g., { options, defaultValue }: {
options: readonly PromptOption<TValue>[], defaultValue?: TValue }) and update
all callers (such as select.tsx where it's invoked) to pass an object instead of
two args; preserve the generic TValue and return type and ensure type
annotations for PromptOption and optional defaultValue remain correct.

---

Outside diff comments:
In `@packages/core/src/context/create-context.ts`:
- Around line 25-33: The JSDoc for CreateContextOptions incorrectly claims a
direct Spinner override; update the documentation in create-context.ts (the
CreateContextOptions docs used by createContext / CommandContext) to remove the
stale "Spinner" injection mention and only list the actual supported overrides
(e.g., Log, Prompts, Status), ensuring the doc text matches the current
CreateContextOptions shape and available overrides.

Verify each finding against the current code and only fix it if needed.

Inline comments:
In `@docs/designs/component-library.md`:
- Around line 645-650: The fenced code block containing the dependency graph
(the block with "foundation", "├── prompts-core", "├── prompts-extended", "└──
display") is missing a language identifier; update that fenced block to use the
plaintext language identifier by changing the opening fence from ``` to ```text
so it matches other plaintext examples in the doc.

In `@packages/core/src/ui/prompts/autocomplete.tsx`:
- Around line 103-106: When handling the down-arrow case in the autocomplete key
handler, guard against an empty filtered list so focusIndex isn't set to -1:
check filtered.length > 0 before computing next and calling setFocusIndex; if
filtered is empty, do nothing (or keep focusIndex at -1/0 per desired behavior).
Update the block that uses key.downArrow, Math.min(filtered.length - 1,
focusIndex + 1), setFocusIndex and the focused = filtered[next] access to only
run when filtered.length > 0 to avoid negative indices and out-of-bounds access.

In `@packages/core/src/ui/prompts/group-multi-select.tsx`:
- Around line 332-337: The key generator itemKey for FlatItem can produce
collisions when two options in the same group have identical labels; update
itemKey to use a stable, unique identifier (e.g., option.value) for option keys
instead of option.label, ensuring option.value is stringified if necessary;
change the option branch in itemKey to generate
`option-${groupName}-${String(option.value)}` and verify the FlatItem/option
types (and any generic TValue) support or coerce to a string to avoid runtime
key collisions.

---

Duplicate comments:
In `@packages/core/src/ui/prompts/select.tsx`:
- Around line 115-125: The list uses option.label as the React key in the
options.map rendering (OptionRow) which can collide for duplicate labels; change
the key to a stable unique identifier such as option.id or, if no id exists, use
the map index only as a fallback (e.g., key={option.id ?? `option-${index}`}) so
each OptionRow has a stable, unique key and avoids
reconciliation/focus/selection bugs.

Verify each finding against the current code and only fix it if needed.

Inline comments:
In `@packages/core/src/ui/prompts/autocomplete.tsx`:
- Around line 93-104: The up-arrow branch for the autocomplete currently only
clamps the lower bound, so if focusIndex is greater than filtered.length - 1 the
new index stays out of range; update the calculation of next in that branch (the
code that sets focusIndex via setFocusIndex) to clamp both ends using
filtered.length - 1 (e.g., compute next = Math.max(0, Math.min(filtered.length -
1, focusIndex - 1))) and then use that next when calling setFocusIndex and
onChange (referencing focusIndex, filtered, setFocusIndex, and onChange).

In `@packages/core/src/ui/prompts/group-multi-select.tsx`:
- Around line 75-80: The focusIndex state is initialized once and can become
out-of-bounds when flatItems (from buildFlatItems using options and
selectableGroups) changes; add a reconciliation effect that runs when flatItems
changes to clamp or reset focusIndex via setFocusIndex to a valid entry (e.g.,
min(current, flatItems.length - 1)) and prefer the first enabled/selectable item
(skip disabled rows) so keyboard navigation and initial focus never point at a
removed or disabled item; reference the flatItems variable,
focusIndex/setFocusIndex state, and the buildFlatItems/selectableGroups logic
when implementing this fix.
- Around line 84-88: The early return in the useInput handler prevents Enter
handling when flatItems is empty; update the handler in useInput (the callback
referencing flatItems) so it does not unconditionally return on flatItems.length
=== 0 — instead only skip navigation/selection logic for empty lists but still
allow the Enter/Return branch to run so non-required prompts can submit [] and
required prompts can run validation; adjust the conditional to check key.name
(e.g., 'return'/'enter') and only bypass other key handling when flatItems is
empty while preserving Enter processing.
- Around line 90-122: Replace the sequential if-returns in the input handler
with a ts-pattern match() dispatch so control flow is explicit and conforms to
the style guide: use match({ key, input }) (or match(key) and match on input
where appropriate) to branch on upArrow, downArrow, input === ' ' (space) and
return; in each arm call the same side-effecting helpers
(setFocusIndex(moveFocus(...)), toggleItem -> setSelected -> setError(undefined)
-> onChange, and onSubmit) and preserve the required validation (required &&
selected.length === 0) and early returns inside the matching arm; update imports
to include match from 'ts-pattern' and keep references to setFocusIndex,
moveFocus, toggleItem, setSelected, onChange, onSubmit unchanged so the behavior
remains identical.

Verify each finding against the current code and only fix it if needed.

Inline comments:
In `@packages/core/src/ui/display/alert.tsx`:
- Around line 182-189: resolveInnerWidth incorrectly measures content using
contentStr.length and a single title length, causing borders from buildTopBorder
and alignLine to misalign for multiline content or when a provided numeric width
is too small; update resolveInnerWidth (and its use of
InnerWidthOptions/title/contentStr) to compute the effective inner width by
splitting contentStr on newlines, taking the maximum length of all content
lines, computing titleWidth as before, and then returning
Math.max(maxContentLineLength, titleWidth, 0) (while still applying the width
!== 'auto' branch: subtract the fixed padding from the provided width but clamp
it to at least that computed max), so top/bottom borders and alignLine will use
a consistent inner width.

In `@packages/core/src/ui/display/progress-bar.tsx`:
- Around line 62-66: Guard against negative or non-integer size before calling
String.repeat by validating and normalizing size and using that normalized value
when computing filledCount and emptyCount; e.g., in the progress bar logic where
size, filledCount, emptyCount, resolveChars(style), chars.filled.repeat and
chars.empty.repeat are used, clamp size to a non-negative integer (e.g., size =
Math.max(0, Math.floor(size))), then compute filledCount = Math.round(ratio *
size) and emptyCount = size - filledCount so both repeats receive non-negative
counts and cannot throw RangeError.

In `@packages/core/src/ui/display/spinner.tsx`:
- Around line 107-128: The spinner can briefly render undefined when `type`
changes because `frameIndex` may be out of bounds for the new `spinner.frames`;
update the component to reset `frameIndex` whenever the spinner `type` (or
`spinner.frames.length`) changes by calling `setFrameIndex(0)` (or clamp to the
new length) in an effect that depends on `type` or `spinner.frames.length` so
`spinner.frames[frameIndex]` is always valid; locate the `frameIndex` state and
the existing useEffect that advances frames and add a new useEffect (or expand
the dependency handling) to reset/clamp `frameIndex` when the spinner identity
or frames length changes.

In `@packages/core/src/ui/display/status-message.tsx`:
- Around line 65-72: resolveIcon currently pattern-matches StatusMessageVariant
but omits the 'primary' variant, so .exhaustive() will throw at runtime for
variant="primary"; update the resolveIcon function to handle 'primary' (e.g.,
add .with('primary', () => symbols.circle) or another appropriate symbols.*
value) so all Variant/StatusMessageVariant cases are covered and the match
remains exhaustive.

In `@packages/core/src/ui/prompts/navigation.ts`:
- Around line 66-79: The function resolveFirstEnabledIndex is exported but sits
under the "// Private" section header; either move the
resolveFirstEnabledIndex<TValue> export out of the private block into the "//
Exports" section (or another appropriate exported section) or change the section
header text to accurately reflect that exported symbols live there — update the
comment near the top that currently reads "// Private" (and any adjacent section
dividers) so the exported function resolveFirstEnabledIndex is grouped under the
correct section header.

In `@packages/core/src/ui/prompts/path-input.tsx`:
- Around line 1-2: The component currently uses blocking node:fs APIs
readdirSync and statSync (e.g., in PathInput) which can freeze the event loop;
replace them with the async counterparts (readdir, stat) and perform directory
reads inside a useEffect or an async handler with proper cancellation/abort
logic, update state with debouncing to avoid spamming reads during fast typing,
and ensure errors are caught and mapped to empty suggestions so the UI stays
responsive during tab completion.

In `@packages/core/src/ui/prompts/select-key.tsx`:
- Around line 16-17: The component SelectKey is rendering only the first
character of PromptOption.value but comparing user input against the full
option.value, causing mismatches for multi-character values; update SelectKey so
it consistently uses the first character of each option for both display and
input matching (e.g., compute const keyChar = option.value[0] and use keyChar in
the rendered key label and in the input comparison) or alternatively
validate/normalize options to single-character values up-front (throw or filter
inside SelectKey) so display and selection logic (options, option.value, and the
input-match code path) remain consistent.

In `@packages/core/src/ui/prompts/select.tsx`:
- Around line 112-114: OptionRow currently uses option.label as the React key
which can collide for duplicate labels; change the key to a stable unique
identifier (e.g., option.id or option.value) on the OptionRow element and ensure
the options array supplies that stable id (or generate a stable id when options
are constructed). Update the OptionRow usage (the JSX that renders <OptionRow
key={...} option={option} />) to reference the unique id field and, if no such
field exists in the options data, add one where options are created (e.g., add
an id property) rather than relying on label or array index.

In `@packages/core/src/ui/prompts/string-utils.ts`:
- Around line 12-14: Change the exported functions removeCharAt and insertCharAt
to accept a single destructured parameter object (e.g., function removeCharAt({
str, index }: { str: string; index: number })) instead of positional params,
update their implementations to use the named properties, and then update all
call sites (notably in path-input.tsx) to pass an object with the appropriate
keys (str, index and for insertCharAt any additional param like char) so the
functions conform to the project rule requiring object destructuring for
exported functions with 2+ parameters.

---

Duplicate comments:
In `@packages/core/src/ui/prompts/autocomplete.tsx`:
- Around line 83-92: The up-arrow handler in the autocomplete (code using
focusIndex, filtered, setFocusIndex) only clamps the lower bound and can operate
on an out-of-range focusIndex when focusIndex > filtered.length-1; before
computing the new index, first clamp the current focusIndex to
Math.min(focusIndex, filtered.length - 1) (or set a local boundedIndex =
Math.min(focusIndex, filtered.length - 1)), then compute next = Math.max(0,
boundedIndex - 1), call setFocusIndex(next) and use filtered[next] for onChange
to guarantee the index is always within [0, filtered.length-1].

In `@packages/core/src/ui/prompts/group-multi-select.tsx`:
- Around line 74-78: The current early return in the useInput handler prevents
the Enter key branch from running when flatItems is empty; update the handler in
group-multi-select's useInput callback so the Enter key is checked and handled
before returning for empty flatItems (or remove the early return and guard only
branches that require items). Concretely, in the useInput ((input, key) => { ...
}) callback, check key.name === "return" first and allow submission logic to run
even if flatItems.length === 0, and keep the empty-flatItems guard only around
navigation/selection logic that depends on flatItems.
- Around line 65-71: The focusIndex is only initialized once and can become
out-of-bounds or point to a disabled row when flatItems (built via
buildFlatItems from options/selectableGroups) changes; add a useEffect that runs
when flatItems changes and clamps/adjusts focusIndex via setFocusIndex so it
stays within 0..flatItems.length-1 and, if the current target is disabled, moves
focus to the nearest enabled item (forward or backward) or to -1/0 as your
component expects; reference focusIndex, setFocusIndex, flatItems, and
buildFlatItems when locating where to add this reconciliation.
- Around line 80-112: Replace the sequential if-return input dispatch with a
ts-pattern match on the input/key combination: locate the handler using
variables key, input, focusIndex, flatItems and functions
setFocusIndex/moveFocus, toggleItem/setSelected/setError, onChange, onSubmit;
implement match() (from ts-pattern) to handle cases for upArrow (moveFocus -1),
downArrow (moveFocus +1), space (toggleItem => setSelected, clear error, call
onChange), and return/enter (validate required -> setError or call onSubmit),
preserving all existing behavior and early returns but expressed as match arms.